import { getNewCartGoods, findCart, mergeCart, insertCart, deleteCart, updateCart, checkAllCart } from '@/apis/cart'

// 购物车状态
export default {
    namespaced: true,
    state: () => {
        return {
            list: []
        }
    },
    // 修改
    mutations: {
        // 设置购物车列表
        setCartList(state, list) {
            state.list = list
        },
        // 修改购物车商品
        updateCart(state, goods) {
            const goodsObj = state.list.find(item => item.skuId === goods.skuId)
            for (const key in goods) {
                // 排除掉无效值 null
                if (goods[key] !== null) {
                    goodsObj[key] = goods[key]
                }
            }
        },
        // 删除购物车商品
        deleteCart(state, skuId) {
            // 方案1：通过过滤实现删除
            state.list = state.list.filter(item => item.skuId !== skuId)
            // 方案2：
            // const index = state.list.findIndex(item => item.skuId === skuId)
            // state.list.splice(index, 1)
        },
        // 加入购物车
        insertCart(state, goodsItem) {
            const index = state.list.findIndex(item => item.skuId === goodsItem.skuId)
            if (index === -1) {
                state.list = [goodsItem, ...state.list]
            } else {
                state.list[index].count += goodsItem.count
            }
        }
    },
    // 异步
    actions: {
        // 封装获取购物车列表的请求
        async getAndSetCartList(store) {
            // 获取购物车列表
            const { result } = await findCart()
            // console.log(result)
            store.commit('setCartList', result)
        },
        // 合并本地购物车
        async mergeLocalCart(store) {
            // console.log(11111, store.state.list)
            const data = store.state.list.map(item => ({ skuId: item.skuId, selected: item.selected, count: item.count }))
            // 注意：合并购物车没有返回值
            await mergeCart(data)
            // 调用获取购物车列表
            store.dispatch('getAndSetCartList')
        },
        // 获取购物车列表
        findCartList(store) {
            return new Promise((resolve, reject) => {
                if (store.rootState.user.profile.token) {
                    // 情况1：已登录，调用接口
                    // 获取并设置购物车列表
                    store.dispatch('getAndSetCartList')
                } else {
                    // 未登录也要同步最新商品信息(价格,库存...)
                    store.state.list.forEach(async (item) => {
                        // 每个商品都要获取最新信息
                        const { result } = await getNewCartGoods(item.skuId)
                        // console.log(result)
                        // skuId 用于查找必传字段，result 是要更新的信息
                        store.commit('updateCart', { skuId: item.skuId, ...result })
                    })
                    resolve('更新成功-本地更新')
                }
            })
        },
        // 更新 SKU 信息 - 删除旧的SKU商品，前添加新的SKU商品
        updateCartSku(store, { oldSkuId, newSku }) {
            return new Promise((resolve, reject) => {
                if (store.rootState.user.profile.token) {
                    // 情况1：已登录，调用接口
                    const oldGoods = store.state.list.find(item => item.skuId === oldSkuId)
                    // 1. 删除旧商品
                    deleteCart([oldGoods.skuId]).then(async () => {
                        // 2. 插入新商品 💥 SKUID 使用新的，💥但是数量是使用旧的
                        await insertCart({ skuId: newSku.skuId, count: oldGoods.count })
                        // 3. 获取并设置列表
                        store.dispatch('getAndSetCartList')
                        // 状态维护
                        resolve('SKU更新成功-接口调用')
                    })
                } else {
                    // 情况2：未登录，直接添加到本地存储中
                    // 1. 获取旧的商品信息
                    const oldGoods = store.state.list.find(item => item.skuId === oldSkuId)
                    // 2. 删除旧的商品
                    store.commit('deleteCart', oldGoods.skuId)
                    // 3. 合并一条新的商品信息
                    console.log(oldGoods, newSku)
                    const newGoods = {
                        ...oldGoods,
                        skuId: newSku.skuId,
                        attrsText: newSku.attrsText,
                        // 后面三个都要改字段名
                        stock: newSku.inventory,
                        nowPrice: newSku.price,
                        price: newSku.oldPrice
                    }
                    // 4. 去插入即可
                    store.commit('insertCart', newGoods)
                    resolve('更新成功')
                }
            })
        },
        // 批量删除选中商品 + 批量删除失效商品
        batchDeleteCart(store, isInvalid = false) {
            return new Promise((resolve, reject) => {
                // 判断用户是否已经登录，可通过 store.rootState 找到总仓库
                if (store.rootState.user.profile.token) {
                    // 情况1：已登录，调用接口
                    const ids = store.getters[isInvalid === true ? 'invalidList' : 'selectedList'].map(item => item.skuId)
                    deleteCart(ids).then(() => {
                        store.dispatch('getAndSetCartList')
                        resolve('删除成功-接口调用')
                    })
                } else {
                    // 情况2：未登录，直接添加到本地存储中
                    // console.log('业务1：删除失效商品')
                    store.getters[isInvalid === true ? 'invalidList' : 'selectedList'].forEach(item => {
                        store.commit('deleteCart', item.skuId)
                    })
                    resolve('删除成功')
                }
            })
        },
        // 做有效商品的全选&反选
        checkAllCart(store, selected) {
            return new Promise((resolve, reject) => {
                // 判断用户是否已经登录，可通过 store.rootState 找到总仓库
                if (store.rootState.user.profile.token) {
                    // 情况1：已登录，调用接口
                    const ids = store.getters.validList.map(item => item.skuId)
                    // console.log({ ids, selected })
                    checkAllCart({ selected, ids }).then(() => {
                        store.dispatch('getAndSetCartList')
                        resolve('批量更新成功-接口调用')
                    })
                } else {
                    // 情况2：未登录，直接添加到本地存储中
                    store.getters.validList.forEach(item => {
                        store.commit('updateCart', { skuId: item.skuId, selected: selected })
                    })
                    resolve('更新成功')
                }
            })
        },
        // 修改购物车商品
        updateCart(store, goods) {
            return new Promise((resolve, reject) => {
                // 判断用户是否已经登录，可通过 store.rootState 找到总仓库
                if (store.rootState.user.profile.token) {
                    // 情况1：已登录，调用接口
                    updateCart(goods).then(() => {
                        store.dispatch('getAndSetCartList')
                        resolve('更新成功-接口调用')
                    })
                } else {
                    // 情况2：未登录，直接添加到本地存储中
                    store.commit('updateCart', goods)
                    resolve('更新成功')
                }
            })
        },
        // 删除购物车商品
        deleteCart(store, skuId) {
            return new Promise((resolve, reject) => {
                // 判断用户是否已经登录，可通过 store.rootState 找到总仓库
                if (store.rootState.user.profile.token) {
                    // 情况1：已登录，调用接口
                    deleteCart([skuId]).then(() => {
                        store.dispatch('getAndSetCartList')
                        resolve('删除商品成功')
                    })
                } else {
                    // 情况2：未登录，直接添加到本地存储中
                    store.commit('deleteCart', skuId)
                    resolve('删除商品成功')
                }
            })
        },
        // 加入购物车
        insertCart(store, goodsItem) {
            return new Promise((resolve, reject) => {
                // console.log(store)
                // 判断用户是否已经登录，可通过 store.rootState 找到总仓库
                if (store.rootState.user.profile.token) {
                    // 情况1：已登录，调用接口
                    insertCart(goodsItem).then(() => {
                        // 加入购物车成功后，直接获取并更新最新列表
                        store.dispatch('getAndSetCartList')
                        // 调用 resolve 可以让 Promise 对象执行 then 的回调函数
                        resolve('加入购物车成功-接口调用')
                    })
                } else {
                    // 情况2：未登录，直接添加到本地存储中
                    store.commit('insertCart', goodsItem)
                    resolve('加入购物车成功-本地')
                }
            })
        }
    },
    // 计算属性
    getters: {
        // 是否全选
        isCheckAll(state, getters) {
            return getters.selectedList.length === getters.validList.length && getters.validList.length !== 0
        },
        // 选中商品总金额 - 依赖选中的商品列表
        selectedAmount(state, getters) {
            return getters.selectedList.reduce((sum, item) => sum + item.nowPrice * item.count, 0).toFixed(2)
        },
        // 选中商品件数 - 依赖选中的商品列表
        selectedTotal(state, getters) {
            return getters.selectedList.reduce((sum, item) => sum + item.count, 0)
        },
        // 选中商品列表 - 依赖有效商品列表
        selectedList(state, getters) {
            return getters.validList.filter(item => item.selected)
        },
        // 无效商品列表
        invalidList(state) {
            return state.list.filter(item => !(item.stock > 0 && item.isEffective))
        },
        // 有效商品列表
        validList(state) {
            // 库存大于 0 并且 有效
            return state.list.filter(item => item.stock > 0 && item.isEffective)
        },
        // 有效商品件数
        validTotal(state, getters) {
            return getters.validList.reduce((sum, item) => sum + item.count, 0)
        },
        // 有效商品总金额
        validAmount(state, getters) {
            return getters.validList.reduce((sum, item) => sum + item.count * item.nowPrice, 0).toFixed(2)
        }
    }
}
